/*
+  @param{Time} want 用户输入时间
+  @return{string}字符串返回时间
 */
// var want = prompt('你要输入的时间，例如:2020-01-05 22:33:55')
var dateFormat = function (want) {
    if(isNaN(Date.parse(want) && !isNaN(parseFloat(want)))){
        return ('输入的不是日期')
    }
    var nowTime =  new Date()
    var pushTime =  new Date(want)
    //得到时间戳的差 单位秒
    var timesDiff = Math.abs((nowTime - pushTime) / 1000)
    // 判断回复什么（内部返回 当前时间 相对 传递的时间 是刚刚,还是几秒前）
    /*
    if(timesDiff == 0){
        return 
    }
    */
   // 判断年月日
   var Y = parseInt(timesDiff / (365 * 24 * 60 * 60))
   var M = parseInt(timesDiff / (30 * 24 * 60 * 60) % 12)
   var D = parseInt(timesDiff) / (24 * 60 * 60 % 365 % 30)
   //判断时分秒
   var H = parseInt(timesDiff / (60 * 60) % 24)
   // 小时格式
   H < 10 ? H = '0' + H : H
   var Mi = parseInt(timesDiff / (60) % 60)
   //分钟格式
   Mi < 10 ? Mi = '0' + Mi : Mi
   var S = parseInt(timesDiff % 60)
   //秒格式
   S < 10 ? S = '0' + S : S
//    console.log('你输入的时间和目前时间差距' + Y + '年' + M + '个月' + D + '天' + H + '小时' + Mi + '分钟' + S +'秒'); 
   var res = '你输入的时间和目前时间差距' + Y + '年' + M + '个月' + D + '天' + H + '小时' + Mi + '分钟' + S +'秒' 
   return res
  
}
/**
 * 快速获取当前时间
 * @param {String} str 举例：YmdHis  Y/m/d
 * @returns String
 */
 function format(str) {
    var d = new Date();
    str = str.replaceAll("Y", d.getFullYear());
    // var m = String(d.getMonth()+1).padStart(2, 0)
    // str = str.replaceAll('m', m)
    str = str.replaceAll("m", zeroize(d.getMonth() + 1));
    str = str.replaceAll("d", zeroize(d.getDate()));
    str = str.replaceAll("H", zeroize(d.getHours()));
    str = str.replaceAll("i", zeroize(d.getMinutes()));
    str = str.replaceAll("s", zeroize(d.getSeconds()));
    return str;
  }
/**
 * 判断浏览器类型
 * @param {} 
 * @return {string}
*/
var time = document.write()
function  browser(time){
   
    if(navigator.userAgent.indexOf('Opera') >-1) return 'Opera浏览器'
    if(navigator.userAgent.indexOf('Trident') >-1) return 'IE浏览器'
    if(navigator.userAgent.indexOf('Firebox') >-1) return '火狐浏览器'
    if(navigator.userAgent.indexOf('Chrome') >-1) return '谷歌浏览器'
    if(navigator.userAgent.indexOf('Safari') >-1) return '苹果浏览器'

}
/**
 * 判断是PC还是移动端
 * @param {} 
 * @returns {string}
*/

function browserPc(){
    data = navigator.userAgent
    if ((data.indexOf('Mac')||data.indexOf('Windows')||data.indexOf('Linux')) !== -1) return '电脑端'
    if ((data.indexOf('iPhone')||data.indexOf('iPad')||data.indexOf('Android')||data.indexOf('Mobile')) !== -1) return '移动端'

}
/**
 * 判断是否是微信内置浏览器
 * @param {} 
 * @returns {string}
*/
var wx = document.write()
function browserWx(){
    if(navigator.userAgent.indexOf('micromessenger')> -1) return '微信内置浏览器'
    else return '不是微信内置浏览器'
}
/**
 * js获取非行内样式判断主流还是非主流浏览器
 * @param {*} tagObj 
 * @param {*} cssAttr 
 * @returns {}
 */
function getStyle(tagObj,cssAttr )
{
if (window.getComputedStyle){
return getComputedStyle(tagObj)[cassAttr]
}  else{
return tagObj.currentStyle[cssAttr] 
}
}
/**
 * 仿写JSON内置API的parse方法
 * @param {String} javaData JSON数据格式
 * @returns Object
 */
 function parse(javaData)
 {
     // let javaData = '{"errcode":0,"errmsg":"ok", "status":true}'
     // 1 去掉【" { } 空格】   => 'errcode:0,errmsg:ok'
     let str = javaData.replace(/"|{|}|\s/g, '')
     // 2 安装【,】分割  => ['errcode:0', 'errmsg:ok']
     let arr = str.split(',')
     // 4 遍历上面：定义空对象
     let obj = {}  
     // 3 遍历 item='errcode:0'
     arr.forEach(item => {
         // 5 遍历里面：按照【:】分割
         let temp = item.split(':') // ['errcode', 0]
         // 6 遍历里面：数组的第一个值就是键，数组的第二个值就是值
         // obj.键 = 值
         // obj.temp[0] = temp[1]
         obj[temp[0]] = isNaN(Number(temp[1])) ? temp[1] : Number(temp[1])
     })
     return obj
 }
 // let str = '{"errcode":0,"errmsg":"ok", "status":true}'
 // console.log(JSON.parse(str))
 // console.log(parse(str));
 /**
  * 仿写JSON内置API的stringify方法
  * @param {Object} obj 标准普通对象
  * @returns String
  */
 function stringify(obj)
 {
 
     // let obj = {"errcode":0,"errmsg":"ok", "status":true}
     // 1 定义空数组
     let arr = []
     // 2 遍历对象，将【键、值】push到数组中
     for (let key in obj)
     {
         // console.log(key, obj.key);
         // console.log(key, obj[key]);
         let val = obj[key]
         if (!['boolean', 'number'].includes(typeof val)) 
         {
             val = `"${obj[key]}"`
         }
         arr.push(`"${key}":${val}`)
     }
     // 3 拼接成json数据格式
     // console.log(`{${arr.join(',')}}`);
     return `{${arr.join(',')}}`
 }

 /**
 * 发送get请求
 * @param {stirng}           url  请求地址
 * @param {object}           params 请求参数
 * @param {function}         callback 回调函数
 * @param {string|undefined} type 返回函数类型
 * @param {object}           headers 自定义请求头
 */
 function get(url,params,callback,type,headers = {}){
    //1创建xhr对象
    let xhr = new XMLHttpRequest()
    //2监控请求状态
    xhr.onreadystatechange = () =>{
        //判断是否返回数据
    if (xhr.readyState === 4) {
        //判断返回状态
        if (xhr.status === 200) {
        //获取返回数据
        let res = xhr.responseText
        if (type === 'json') res = JSON.parse(res)
        callback(res)
        } else {
            console.log('错误',xhr.status)
        }
    }
    }
    //3设置请求方式，请求地址
    //3.1定义空数组
    let temp = []
    //3.2遍历对象
    for (let key in params){
        //3.3把对象中的值push空数组中 键=值 
        temp.push(`${key}=${params[key]}`)
    }
    //数组变字符串
    xhr.open('get',`${url}?${temp.join('&')}`)
    //自定义请求头
    for (let key in headers){
        xhr.setRequestHeader(key,headers[key])
    }
    //4发送请求
    xhr.send(null)
    }
    
    /**
 * 发送post异步请求
 * @param {string} url 请求地址
 * @param {object} params 请求参数  {参数名:数据,...,参数名:数据} 转换 参数名=数据&...&参数名=数据
 * @param {function} callback 回调函数写不同逻辑的 有一个形参res是接口数据
 * @param {string|null} type 后端返回数据类型
 * @param {object} headers 自定义请求头  
 */
function post(url, params, callback, type = null, headers = {})   
{
    // 一、创建xhr对象
    const xhr = new XMLHttpRequest
    // 二、监控请求状态
    xhr.onreadystatechange = () => {
        // 判断是否返回数据
        if (xhr.readyState === 4) 
        {
            // 判断返回的状态
            if (xhr.status === 200) 
            {
                // 获取数据
                // let res = JSON.parse(xhr.responseText)
                let res = xhr.responseText
                if (type==='json') res = JSON.parse(res)
                // 不同逻辑处理（n行代码）
                callback(res)
            } else {
                console.log('瑕疵：', xhr.status)
            }
        }
    }
    // 三、设置请求方式、请求地址
    xhr.open('post', url)
    xhr.setRequestHeader('content-type', 'application/x-www-form-urlencoded') 
    for (let key in headers)
    {
        xhr.setRequestHeader(key, headers[key]) 
    }
    // 四、发送
  let params =  {a:1,b:2}
    // 1 定义空数组temp 存放参数
    let temp = []
    // 2 遍历对象
    for (let key in params)
    {
        // 3 将对象中的数据 push到空数组temp中
        temp.push(`${key}=${params[key]}`) 
    }
    xhr.send(temp.join('&'))
}


// 导出
export {get, post} 


/**
 * promise发送get请求
 * @param {string} url 请求地址
 * @param {object} params 请求参数
 * @param {string|undefined} type 返回的接口数据类型
 * @param {object} headers 自定义请求头
 * @returns promise
 */

 function get(url,params,type,headers = {}){
    //过滤params数据
    let temp = []
    for (let key in params) {
    temp.push(`${key}=${params[key]}`)
  }
  let paramsFilter = temp.join('&')
  //返回promise对象
  const p = new Promise((resolve,reject) => {
//1创建xhr对象
const xhr = new XMLHttpRequest
//2监控请求状态
xhr.onreadystatechange = () =>{
if (xhr.readyState === 4) {
    if (xhr.status === 200) {
     let res = xhr.responseText
     if (type === 'json') res = JSON.parse(res)
     resolve(res)
    } else {
     reject(xhr.status)
    }
}
}
// 3，设置请求方式地址
xhr.open('get',`${url}?${paramsFilter}`)
//请求头转换
for (let key in headers) {
    xhr.setRequestHeader(key,headers[key])
}
// 4，发送请求
xhr.send(null)
})
return p
}

// 开启loading
// get(url, params, type, headers={})
// .then()
// .catch()
// .finally(() => 隐藏loading)

/**
 * promise发送post请求
 * @param {string} url 请求地址
 * @param {object} params 请求参数
 * @param {string|undefined} type 返回的接口数据类型
 * @param {object} headers 自定义请求头
 * @returns Promise
 */
 function post(url, params, type, headers={})
 {
     // 过滤数据
     let temp = []
     for (let key in params)
     {
         temp.push(`${key}=${params[key]}`)
     }
     let paramsFilter = temp.join('&')
 
     // 返回promise对象
     const p = new Promise((resolve, reject) => {
         const xhr = new XMLHttpRequest 
         xhr.onreadystatechange = () => {
             if (xhr.readyState === 4)
             {
                 if (xhr.status === 200)
                 {
                     let res = xhr.responseText
                     if (type==='json') res = JSON.parse(res)
                     resolve(res) 
                 } else {
                     reject(xhr.status) 
                 }
             }
         }
         xhr.open('post', url)
         xhr.setRequestHeader('content-type', 'application/x-www-form-urlencoded')
         for (let key in headers) 
         {
             xhr.setRequestHeader(key, headers[key])
         }
         xhr.send(paramsFilter)
     })
     
     return p
 }
 

 /**
 * 获取地址参数
 * @param {string} key
 * @returns 
 */
 function getparams(key) {
    let url = decodeURI(location.href)
    // let arr = (url.split('?')).pop()
    // let arr1=arr.pop()
    let arr2 = url.split('?').pop().split('&')
    // console.log(arr2)    //prod=pc,wd=html
    arr2.forEach(item => {
        let arr3 = item.split('=')
        // console.log(arr3);
        if (arr3[0] == key) key = arr3[1]
    })
    return key

}
